Internet Mapping Clients: Basic HTML, Javascript, CSS; Google Maps API; OpenLayers javascript library
Geospatial Services Oriented Architectures (SOA)
Open Standards: Open Geospatial Consortium (OGC - WMS, WFS, WCS, KML); Extensible Markup Language (XML)
Desktop client use of Open Standards
Data sharing/publication using Open Standards
Basics
Outline
What is Internet Mapping?
Definitions
Tools
What is Internet Mapping
Extended Desktop Mapping
Use of open standards based remote data and map services in desktop applications
Geospatial Data Sharing
Establishing open standards based services to share geospatial data and mapping capabilities over the Internet
Web-client Mapping
The delivery of mapping and geospatial data tools through web browsers, again based upon open standards
Definitions
Internet
The global computer network of computers that typically connect with each other over TCP/IP
World Wide Web
The subset of applications that are run over the Internet, typically using the HTTP protocol in combination with data (HTML, XML, XHTML), presentation (CSS), and behavior (JavaScript) components
Mapping
The generation of cartographic products that include map images (pictures of geospatial data) and other elements (e.g. legends, tools, scale information, north-arrow)
Definitions
Analysis
The development of models (statistical and otherwise) that enable the exploration of geospatial data and testing of hypotheses using those data
Open Standards
While the definition varies from one organization to the next, Open Standards are often characterized by the following:
Developed through a public process by a national or international standards group
May be implemented royalty-free
Definitions
Interoperability
Ability of systems to share data and information with each other
COTS
Commercial Off-the-Shelf Software. Applications that are “purchased” from vendors, often with license terms that restrict the use the software to the specific platform for which it is licensed. Often comes with implicit or explicit technical support
Open Source
Software licensed under terms that are consistent with the Open Source definition, which includes access to source code, and freedom to modify and redistribute
Definitions
Data
Actual values associated with geographic locations. For example - numeric elevation values associated with locations within a Digital Elevation Model.
Metadata
Data about a particular data product or service. Metadata provide critical documentation that supports the discovery and use of data products and data and mapping services
Tools
Computer Hardware Requirements
At least 2 GB RAM
At least 20 GB of available disk space
Internet Connection (broadband [>728 Kb/sec] recommended)
Software Requirements
Supported Operating System
Geographic Information System (GIS)
Text Editor
Secure File Transfer Protocol Client
Secure Shell (SSH) Client
Web Browser (at least one of the following)
A desktop Git/GitHub client for your operating system of choice
<html><!-- The HTML block is the container for all of your page content --><head><!-- The head is where you include pointers to external resources (i.e. style sheets and javascript files), blocks of Javascript code , styles, etc. --><title>The page title also goes in here</title></head><body><!-- The body is where you put all of the content for the page (i.e. the material that will be displayed in the web browser) --><h1>Headers</h1><div>Generic blocks of content</div><p>Paragraphs</p><table>Tables</table><img...>Images</img><form...>Forms</form><ul>Unordered Lists</ul><ol>Ordered Lists</ol><li>List Items</li><!-- Javascript can go here as well --></body></html>
The most interoperable language for adding dynamic behavior to web sites is Javascript - supported by most browsers on most operating systems
A full-fledged programming language
A non-trivial undertaking to become proficient in
Experience in other programming languages can contribute to learning Javascript
Defines actions that may be taken on/by DOM elements
Allows for modification of existing DOM elements, creation of new DOM elements after the page has finished loading from the server, retrieval of new content after page loads
An interactive web page that may behave like a local desktop application
<html><head><meta http-equiv="Content-Type" content="text/html;charset=utf-8"/><title>This is a simple web page</title></head><body><h1>They don't get any simpler than this!</h1><p>OK, not much simpler than this.</p><p>Hello World?</p></body></html>
<html><head><meta http-equiv="Content-Type" content="text/html;charset=utf-8"/><title>This is a simple web page - with styling</title><style type="text/css">
h1 {color:blue;font-size:large}
p.para{color:#777777;font-size:small}#annoying{color:red;text-decoration:line-through}</style></head><body><h1>They don't get any simpler than this!</h1><p class="para">OK, not much simpler than this.</p><p id="annoying" class="para">Hello World?</p></body></html>
<html><head><meta http-equiv="Content-Type" content="text/html;charset=utf-8"/><title>This is a simple web page with Javascript</title><script type="text/javascript">functiongenericAlert() {alert("You just did something ...")
document.getElementById("clickMe").style.color="red"}</script> </head><body><h1>They don't get any simpler than this!</h1><p>OK, not much simpler than this.</p> <p>Hello World?</p><p id="clickMe" onclick="genericAlert();">What happens when you click me?</p> </body></html>
NAWRS Mapper. HTML: 39 Lines; CSS: 136 Lines; core.js: 515 Lines + Google Maps API and JQuery Framework
Week 3- Module 2a - Web-based Mapping Clients. Google Maps API
Outline
What is an API
The Google Maps API
Version
Reference Information
Key Components
Examples
What is an API
API Stands for Application Programming Interface
An Application Programming Interface (API) is a particular set of rules and specifications that a software program can follow to access and make use of the services and resources provided by another particular software program that implements that API. It serves as an interface between different software programs and facilitates their interaction, similar to the way the user interface facilitates interaction between humans and computers. -- From Wikipedia: http://en.wikipedia.org/wiki/Api
The Google Maps API provides an interface for interacting with Google’s mapping services from external web applications
Google Maps API Version
The version of the Google Maps API used in this class is v3 of the Javascript API
points depicted by specified or defined icons at locations within the map
Polyline
linear features defined by multiple points with a defined style for the line
Polygon
closed features defined by multiple points. Supports multi-polygons, and donuts. Line and fill styles may be specified.
(Ground) Overlay Maps
Image-based map layers that replace or overlay Google layers - registered to the map coordinates
Overlays (continued)
Info Windows
floating content windows for displaying content defined as HTML, a DOM element, or text string
Layers
Grouped display content assigned to a specific layer type: Data (including GeoJSON), KmlLayer (& GeoRSS), Heatmap, FusionTablesLayer, TrafficLayer, TransitLayer BicyclingLayer
Custom Overlays
definition of programmatically controlled layers
Services
Geocoding Service
Forward and reverse geocoding:
address to LatLon
LatLon to Nearest Address
May be biased to current viewport, region
Directions
Based upon an origin, destination, and a variety of additional options
Available directions and rendered route
Distance Matrix
Travel distance and duration given a specific mode of travel
Services
Elevation
Delivery of elevation data for locations or paths
Streetview
Integration of Google Streetview within a DOM element
Maximum Zoom
Provides information about the maximum available zoom level
Events
Events provide the ability to attach custom behaviors to events in the interface. For example:
Changing items in the interface as the user zooms in on a map
Displaying additional information outside the map when the user clicks a location in the map
Synchronizing the behavior of multiple maps as the user interacts with one map
Requires higher-level Javascript than we will cover in this course
<!DOCTYPE html><html><head><link rel="stylesheet" type="text/css" href="css/mapPage.css"></head><body><h1>Sample Map</h1><div id="map_canvas"></div><!-- Let's put our JavaScript down here ---------------------------------------------><!-- Load the external JavaScript file with the map definition code --><script src="js/mapPage_01.js"></script><!-- Load the API in asynchronous mode and execute the initialize function when done --><!-- The optional 'key-<API Key>' parameter is not used here but should be for a production map --><script async defer src="https://maps.googleapis.com/maps/api/js?callback=initialize"></script></body></html>
/* You must set the height of either the 'html' or 'body' elements for some browsers to properly render the map with a hight taller than 0px */
html {height:100%}
body {height:100%;margin:0px;padding:0px;background-color:black;color:#CCCCCC;text-align:center}#map_canvas{width:90%;height:80%;margin-left:auto;margin-right:auto}.infoBox{color:black}
mapPage_01.js
1
2
3
4
5
6
7
8
9
10
11
12
function initialize() {
var classroom = new google.maps.LatLng(35.084280,-106.624073)
var mapOptions = {
zoom: 8,
center: classroom,
mapTypeId: google.maps.MapTypeId.ROADMAP
};
var map = new google.maps.Map(
document.getElementById("map_canvas"),
mapOptions);
}
<!DOCTYPE html><html><head><link rel="stylesheet" type="text/css" href="css/mapPage.css"></head><body><h1>Sample Map</h1><div id="map_canvas"></div><!-- Let's put our JavaScript down here ---------------------------------------------><!-- Load the external JavaScript file with the map definition code --><script src="js/mapPage_02.js"></script><!-- Load the API in asynchronous mode and execute the initialize function when done --><!-- The optional 'key-<API Key>' parameter is not used here but should be for a production map --><script async defer src="https://maps.googleapis.com/maps/api/js?callback=initialize"></script></body></html>
mapPage_02.js
1
2
3
4
5
6
7
8
9
10
11
12
function initialize() {
var classroom = new google.maps.LatLng(35.084280,-106.624073)
var mapOptions = {
zoom: 8,
center: classroom,
mapTypeId: google.maps.MapTypeId.SATELLITE
};
var map = new google.maps.Map(
document.getElementById("map_canvas"),
mapOptions);
}
<!DOCTYPE html><html><head><link rel="stylesheet" type="text/css" href="css/mapPage.css"></head><body><h1>Sample Map</h1><div id="map_canvas"></div><!-- Let's put our JavaScript down here ---------------------------------------------><!-- Load the external JavaScript file with the map definition code --><script src="js/mapPage_03.js"></script><!-- Load the API in asynchronous mode and execute the initialize function when done --><!-- The optional 'key-<API Key>' parameter is not used here but should be for a production map --><script async defer src="https://maps.googleapis.com/maps/api/js?callback=initialize"></script></body></html>
mapPage_03.js
1
2
3
4
5
6
7
8
9
10
11
12
function initialize() {
var classroom = new google.maps.LatLng(35.084280,-106.624073)
var mapOptions = {
zoom: 8,
center: classroom,
mapTypeId: google.maps.MapTypeId.HYBRID
};
var map = new google.maps.Map(
document.getElementById("map_canvas"),
mapOptions);
}
<!DOCTYPE html><html><head><link rel="stylesheet" type="text/css" href="css/mapPage.css"></head><body><h1>Sample Map</h1><div id="map_canvas"></div><!-- Let's put our JavaScript down here ---------------------------------------------><!-- Load the external JavaScript file with the map definition code --><script src="js/mapPage_04.js"></script><!-- Load the API in asynchronous mode and execute the initialize function when done --><!-- The optional 'key-<API Key>' parameter is not used here but should be for a production map --><script async defer src="https://maps.googleapis.com/maps/api/js?callback=initialize"></script></body></html>
mapPage_04.js
1
2
3
4
5
6
7
8
9
10
11
12
function initialize() {
var classroom = new google.maps.LatLng(35.084280,-106.624073)
var mapOptions = {
zoom: 8,
center: classroom,
mapTypeId: google.maps.MapTypeId.TERRAIN
};
var map = new google.maps.Map(
document.getElementById("map_canvas"),
mapOptions);
}
<!DOCTYPE html><html><head><link rel="stylesheet" type="text/css" href="css/mapPage.css"></head><body><h1>Sample Map</h1><div id="map_canvas"></div><!-- Let's put our JavaScript down here ---------------------------------------------><!-- Load the external JavaScript file with the map definition code --><script src="js/mapPage_05.js"></script><!-- Load the API in asynchronous mode and execute the initialize function when done --><!-- The optional 'key-<API Key>' parameter is not used here but should be for a production map --><script async defer src="https://maps.googleapis.com/maps/api/js?callback=initialize"></script></body></html>
mapPage_05.js
1
2
3
4
5
6
7
8
9
10
11
12
function initialize() {
var classroom = new google.maps.LatLng(35.084280,-106.624073)
var mapOptions = {
zoom: 18,
center: classroom,
mapTypeId: google.maps.MapTypeId.TERRAIN
};
var map = new google.maps.Map(
document.getElementById("map_canvas"),
mapOptions);
}
<!DOCTYPE html><html><head><link rel="stylesheet" type="text/css" href="css/mapPage.css"></head><body><h1>Sample Map</h1><div id="map_canvas"></div><!-- Let's put our JavaScript down here ---------------------------------------------><!-- Load the external JavaScript file with the map definition code --><script src="js/mapPage_06.js"></script><!-- Load the API in asynchronous mode and execute the initialize function when done --><!-- The optional 'key-<API Key>' parameter is not used here but should be for a production map --><script async defer src="https://maps.googleapis.com/maps/api/js?callback=initialize"></script></body></html>
mapPage_06.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
function initialize() {
var classroom = new google.maps.LatLng(35.084280,-106.624073)
var myOptions = {
zoom: 18,
center: classroom,
mapTypeId: google.maps.MapTypeId.HYBRID,
zoomControl: true,
zoomControlOptions: {style: google.maps.ZoomControlStyle.SMALL},
mapTypeControl: true,
mapTypeControlOptions: {
style: google.maps.MapTypeControlStyle.DROPDOWN_MENU},
streetViewControl: false
};
var map = new google.maps.Map(
document.getElementById("map_canvas"),
myOptions);
}
<!DOCTYPE html><html><head><link rel="stylesheet" type="text/css" href="css/mapPage.css"></head><body><h1>Sample Map</h1><div id="map_canvas"></div><!-- Let's put our JavaScript down here ---------------------------------------------><!-- Load the external JavaScript file with the map definition code --><script src="js/mapPage_07.js"></script><!-- Load the API in asynchronous mode and execute the initialize function when done --><!-- The optional 'key-<API Key>' parameter is not used here but should be for a production map --><script async defer src="https://maps.googleapis.com/maps/api/js?callback=initialize"></script></body></html>
<!DOCTYPE html><html><head><link rel="stylesheet" type="text/css" href="css/mapPage.css"></head><body><h1>Sample Map</h1><div id="map_canvas"></div><!-- Let's put our JavaScript down here ---------------------------------------------><!-- Load the external JavaScript file with the map definition code --><script src="js/mapPage_08.js"></script><!-- Load the API in asynchronous mode and execute the initialize function when done --><!-- The optional 'key-<API Key>' parameter is not used here but should be for a production map --><script async defer src="https://maps.googleapis.com/maps/api/js?callback=initialize"></script></body></html>
<!DOCTYPE html><html><head><link rel="stylesheet" type="text/css" href="css/mapPage.css"></head><body><h1>Sample Map</h1><div id="map_canvas"></div><!-- Let's put our JavaScript down here ---------------------------------------------><!-- Load the external JavaScript file with the map definition code --><script src="js/mapPage_09.js"></script><!-- Load the API in asynchronous mode and execute the initialize function when done --><!-- The optional 'key-<API Key>' parameter is not used here but should be for a production map --><script async defer src="https://maps.googleapis.com/maps/api/js?callback=initialize"></script></body></html>
function initialize() {
var classroom = new google.maps.LatLng(35.084280,-106.624073)
var office = new google.maps.LatLng(35.084506,-106.624899)
var myOptions = {
zoom: 18,
center: classroom,
mapTypeId: google.maps.MapTypeId.HYBRID
};
var map = new google.maps.Map(
document.getElementById("map_canvas"),
myOptions);
var classroomMarker = new google.maps.Marker({
position: classroom,
title:"Geography 485L/585L Classroom, Bandelier East, Room 106"
});
classroomMarker.setMap(map);
var officeMarker = new google.maps.Marker({
position: office,
title:"Office, Bandelier West, Room 107"
});
officeMarker.setMap(map);
var buildingCoordinates = [
new google.maps.LatLng(35.084498,-106.624921),
new google.maps.LatLng(35.084558,-106.624911),
new google.maps.LatLng(35.084566,-106.624970),
new google.maps.LatLng(35.084609,-106.624966),
new google.maps.LatLng(35.084544,-106.624383),
new google.maps.LatLng(35.084438,-106.624317),
new google.maps.LatLng(35.084384,-106.623922),
new google.maps.LatLng(35.084164,-106.623970),
new google.maps.LatLng(35.084214,-106.624324),
new google.maps.LatLng(35.084214,-106.624324),
new google.maps.LatLng(35.084391,-106.624284)
];
var bldgPoly = new google.maps.Polygon({
paths: buildingCoordinates,
strokeColor: "#FF0000",
strokeOpacity: 0.8,
strokeWeight: 2,
fillColor: "#FF0000",
fillOpacity: 0.35
});
bldgPoly.setMap(map)
}
<!DOCTYPE html><html><head><link rel="stylesheet" type="text/css" href="css/mapPage.css"></head><body><h1>Sample Map</h1><div id="map_canvas"></div><!-- Let's put our JavaScript down here ---------------------------------------------><!-- Load the external JavaScript file with the map definition code --><script src="js/mapPage_10.js"></script><!-- Load the API in asynchronous mode and execute the initialize function when done --><!-- The optional 'key-<API Key>' parameter is not used here but should be for a production map --><script async defer src="https://maps.googleapis.com/maps/api/js?callback=initialize"></script></body></html>
function initialize() {
var classroom = new google.maps.LatLng(35.084280,-106.624073)
var office = new google.maps.LatLng(35.084506,-106.624899)
var myOptions = {
zoom: 18,
center: classroom,
mapTypeId: google.maps.MapTypeId.HYBRID
};
var map = new google.maps.Map(
document.getElementById("map_canvas"),
myOptions);
var classroomMarker = new google.maps.Marker({
position: classroom,
title:"Geography 485L/585L Classroom, Bandelier East, Room 106"
});
classroomMarker.setMap(map);
var officeMarker = new google.maps.Marker({
position: office,
title:"Office, Bandelier West, Room 107"
});
officeMarker.setMap(map);
var buildingCoordinates = [
new google.maps.LatLng(35.084498,-106.624921),
new google.maps.LatLng(35.084558,-106.624911),
new google.maps.LatLng(35.084566,-106.624970),
new google.maps.LatLng(35.084609,-106.624966),
new google.maps.LatLng(35.084544,-106.624383),
new google.maps.LatLng(35.084438,-106.624317),
new google.maps.LatLng(35.084384,-106.623922),
new google.maps.LatLng(35.084164,-106.623970),
new google.maps.LatLng(35.084214,-106.624324),
new google.maps.LatLng(35.084214,-106.624324),
new google.maps.LatLng(35.084391,-106.624284)
];
var bldgPoly = new google.maps.Polygon({
paths: buildingCoordinates,
strokeColor: "#FF0000",
strokeOpacity: 0.8,
strokeWeight: 2,
fillColor: "#FF0000",
fillOpacity: 0.35
});
bldgPoly.setMap(map);
var classInfoContent = '<div class="infoBox">' +
'<p>This is the location for the Geography 485L/585L class</p>' +
'</div>'
var classInfoWindow = new google.maps.InfoWindow({
content: classInfoContent
});
google.maps.event.addListener(classroomMarker, 'click', function() {
classInfoWindow.open(map,classroomMarker);
});
}
Week 4 - Module 2a - Web-based Mapping Clients. Google Maps API (pt. 2)
Overview
Additional Google Maps API Capabilities to be Aware of
<!DOCTYPE html><html><head><link rel="stylesheet" type="text/css" href="css/mapPage.css"></head><body><h1>Sample Map - Styled (POIs Highlighted)</h1><div id="map_canvas"></div><!-- Let's put our JavaScript down here ---------------------------------------------><!-- Load the external JavaScript file with the map definition code --><script src="js/mapPage_styled.js"></script><!-- Load the API in asynchronous mode and execute the initialize function when done --><!-- The optional 'key-<API Key>' parameter is not used here but should be for a production map --><script async defer src="https://maps.googleapis.com/maps/api/js?callback=initialize"></script></body></html>
<!DOCTYPE html><html><head><link rel="stylesheet" type="text/css" href="css/event_mapPage.css"><title>Karl's Event Diary</title></head><body><h1>My diary of endurance events that I've participated in since joining Team in Training
</h1><p>In 2008 Cynthia and I joined the Leukemia and Lymphoma Society's
(<a href="http://www.lls.org/">LLS</a>) Team in Training
(<a href="http://www.teamintraining.org/">TNT</a>,
<a href="http://youtu.be/GMSKG8L6K78">info video</a>) program as
participants to train for the Animas Valley/Steamworks Half Marathon
and raise money for blood cancer research and patient services. In spite of
our not having any direct connection to blood cancer (at that time),
we found the goals of LLS admirable, the combined training and fund-raising
program of TNT a great idea, and have made many new friends over the many
seasons that we've been involved with TNT.</p><p>From 2008 through early 2015 we continued to volunteer with TNT, as
participants, mentors, and since 2010 I was a coach (check out my
<a href="http://youtu.be/GMSKG8L6K78#t=2m13s">half-second</a> of fame in the
info video) for TNT with an emphasis on training walkers for full- or
half-marathons. This page provides a summary of the events that I've participated
in in some capacity since we became involved with TNT. </p><div id="event-map" name="event-map"></div><h2><span class="date">11/13/2015</span>
Avengers Half Marathon
<span class="time">3:17:55</span>
(<a href="#event-map" onclick="recenter(map, eventPlaces[5].point, 12)">map</a>)
</h2><h2><span class="date">1/11/2015</span>
Disney World Marathon (Goofy - Day 2)
<span class="time">6:21:01</span>
(<a href="#event-map" onclick="recenter(map, eventPlaces[4].point, 10)">map</a>)
</h2><p class="eventDescription">blah, blah, blah ...</p><h2><span class="date">1/10/2015</span>
Disney World Half Marathon (Goofy - Day 1)
<span class="time">2:45:55</span>
(<a href="#event-map" onclick="recenter(map, eventPlaces[4].point, 10)">map</a>)
</h2><h2><span class="date">10/19/2014</span>
Duke City Half Marathon
<span class="time">2:45:17</span>
(<a href="#event-map" onclick="recenter(map, eventPlaces[0].point, 11)">map</a>)
</h2><p class="eventDescription">blah, blah, blah ...</p><h2><span class="date">2/23/2014</span>
Princess Half Marathon
<span class="time">3:07:11</span>
(<a href="#event-map" onclick="recenter(map, eventPlaces[4].point, 10)">map</a>)
</h2><h2><span class="date">2/22/2014</span>
Princess Enchanted 10k
<span class="time">1:42:43</span>
(<a href="#event-map" onclick="recenter(map, eventPlaces[4].point, 10)">map</a>)
</h2><h2><span class="date">9/1/2013</span>
Disneyland Half Marathon
<span class="time">2:56:57</span>
(<a href="#event-map" onclick="recenter(map, eventPlaces[5].point, 12)">map</a>)
</h2><p class="eventDescription">blah, blah, blah ...</p><h2><span class="date">1/13/2013</span>
Disney World Marathon (Goofy - Day 2)
<span class="time">6:46:57</span>
(<a href="#event-map" onclick="recenter(map, eventPlaces[4].point, 10)">map</a>)
</h2><p class="eventDescription">blah, blah, blah ...</p><h2><span class="date">1/12/2013</span>
Disney World Half Marathon (Goofy - Day 1)
<span class="time">3:22:48</span>
(<a href="#event-map" onclick="recenter(map, eventPlaces[4].point, 10)">map</a>)
</h2><p class="eventDescription">blah, blah, blah ...</p><h2><span class="date">9/29/2012</span>
Hot Chocolate 15k
<span class="time">1:56:46</span>
(<a href="#event-map" onclick="recenter(map, eventPlaces[6].point, 10)">map</a>)
</h2><p class="eventDescription">blah, blah, blah ...</p><h2><span class="date">6/9/2012</span>
Animas Valley/Steamworks Half Marathon
<span class="time">no time: coached</span>
(<a href="#event-map" onclick="recenter(map, eventPlaces[1].point, 10)">map</a>)
</h2><p class="eventDescription">blah, blah, blah ...</p><h2><span class="date">1/9/2012</span>
Disney World Marathon (Goofy - Day 2)
<span class="time">6:56:28</span>
(<a href="#event-map" onclick="recenter(map, eventPlaces[4].point, 10)">map</a>)
</h2><p class="eventDescription">blah, blah, blah ...</p><h2><span class="date">1/8/2011</span>
Disney World Half Marathon (Goofy - Day 1)
<span class="time">3:29:00</span>
(<a href="#event-map" onclick="recenter(map, eventPlaces[4].point, 10)">map</a>)
</h2><p class="eventDescription">blah, blah, blah ...</p><h2><span class="date">6/19/2010</span>
Animas Valley/Steamworks Half Marathon
<span class="time">no time: coached</span>
(<a href="#event-map" onclick="recenter(map, eventPlaces[1].point, 10)">map</a>)
</h2><p class="eventDescription">blah, blah, blah ...</p><h2><span class="date">6/6/2010</span>
San Diego Rock 'n' Roll Marathon
<span class="time">no time: coached</span>
(<a href="#event-map" onclick="recenter(map, eventPlaces[2].point, 11)">map</a>)
</h2><p class="eventDescription">blah, blah, blah ...</p><h2><span class="date">10/18/09</span>
Nike Women's Marathon
<span class="time">7:13:05</span>
(<a href="#event-map" onclick="recenter(map, eventPlaces[3].point, 12)">map</a>)
</h2><p class="eventDescription">blah, blah, blah ...</p><h2><span class="date">9/6/2009</span>
Disneyland Half Marathon
<span class="time">3:43:05</span>
(<a href="#event-map" onclick="recenter(map, eventPlaces[5].point, 12)">map</a>)
</h2><p class="eventDescription">blah, blah, blah ...</p><h2><span class="date">1/11/2009</span>
Disney World Marathon
<span class="time">6:57:42</span>
(<a href="#event-map" onclick="recenter(map, eventPlaces[4].point, 10)">map</a>)
</h2><p class="eventDescription">blah, blah, blah ...</p><h2><span class="date">10/19/2008</span>
Duke City Half Marathon
<span class="time">3:09:42</span>
(<a href="#event-map" onclick="recenter(map, eventPlaces[0].point, 11)">map</a>)
</h2><p class="eventDescription">blah, blah, blah ...</p><h2><span class="date">6/21/2008</span>
Animas Valley/Steamworks Half Marathon
<span class="time">3:14:52</span>
(<a href="#event-map" onclick="recenter(map, eventPlaces[1].point, 10)">map</a>)
</h2><p class="eventDescription">blah, blah, blah ...</p></body><!-- Let's put our JavaScript down here ---------------------------------------------><!-- Load the external JavaScript file with the map definition code --><script src="js/mapPage_events.js"></script><!-- Load the API in asynchronous mode and execute the initialize function when done --><!-- The optional 'key-<API Key>' parameter is not used here but should be for a production map --><script async defer src="https://maps.googleapis.com/maps/api/js?callback=initialize"></script></body></html>
var map;
var eventPlaces;
function initialize() {
// Define a set of global coordinates for use throughout the web site
// Place coordinates derived from GNIS database: http://geonames.usgs.gov/pls/gnispublic
eventPlaces = [
{
name: "Albuquerque",
point: new google.maps.LatLng(35.0889356,-106.5747462),
label: "Albuquerque: Duke City Half Marathon"
},
{
name: "Durango",
point: new google.maps.LatLng(37.2752800,-107.8800667),
label: "Durango: Animas Valley/Steamworks Half Marathon"
},
{
name: "San Diego",
point: new google.maps.LatLng(32.7153292,-117.1572551),
label: "San Diego: San Diego Rock 'n' Roll Marathon"
},
{
name: "San Francisco",
point: new google.maps.LatLng(37.7749295,-122.4194155),
label: "San Francisco: Nike Women's Marathon"
},
{
name: "Orlando",
point: new google.maps.LatLng(28.5383355,-81.3792365),
label: "Orlando: Walt Disney World half- and full-marathon"
},
{
name: "Anaheim",
point: new google.maps.LatLng(33.8352932,-117.9145036),
label: "Anaheim: Disneyland Half Marathon"
},
{
name: "Albuquerque",
point: new google.maps.LatLng(35.0889356,-106.5747462),
label: "Hot Chocolate 15k"
}
];
var myOptions = {
zoom: 4,
center: eventPlaces[0].point,
mapTypeId: google.maps.MapTypeId.ROADMAP};
map = new google.maps.Map(
document.getElementById("event-map"),
myOptions);
addMarkers(map,eventPlaces)
}
function recenter(mapName, latlon, zoomLevel) {
mapName.setCenter(latlon);
mapName.setZoom(zoomLevel)
}
function addMarkers(mapName, markerArray) {
for (index = 0; index < markerArray.length; index++) {
myMarker = new google.maps.Marker({
position: markerArray[index].point,
title: markerArray[index].label
});
myMarker.setMap(mapName)
}
}
Vector data represent phenomena that are associated with specific bounded locations, typically represented by:
Points
Lines
Polygons
Vector data include:
The geometries that describe the area being referenced, and
Attributes associated with that area
For example, a census vector data product might include the geometries that define census tracts and attributes associated with each geometry: population, income, etc.
Data Types - Raster
Raster data are frequently used to represent values for phenomena that vary continuously across space (e.g. elevation, concentration of air pollutants, depth to ground water, etc. )
These values are encoded over a regular grid of observation locations with a specified grid spacing - often referred to as the spatial resolution of the dataset (i.e. 10m resolution for a standard USGS Digital Elevation Model product)
Often parts of data collections that are repeated (i.e. remote sensing data products)
Accessing and Processing Raster and Vector Data
ArcGIS - ArcCatalog
QGIS - Dataset properties available through the "Metadata" tab
Through metadata files available from the provider web site or embedded in the downloaded file
Accessing and Processing Raster and Vector Data - Programmatically
Two geospatial libraries and their related utility programs provide information about and tools for modifying vector and raster data sets
OGR
vector data access and information
GDAL
raster data access and information
These libraries are the data access and processing foundation for a growing number of open source and commercial mapping systems
To convert locations from a 3-dimensional oblate spherical coordinate system (such as is commonly used to represent the surface of the earth) to a 2-dimensional representation in a map, a coordinate transformation must be performed.
There are a limitless number of potential coordinate transformations possible, and a large number have been named and defined that meet specific cartographic or other requirements
EPSG Codes
A catalog of numeric codes and associated coordinate transformation parameters is maintained by the International Association of Oil & Gas Producers (OGP) - the successor scientific organization to the European Petroleum Survey Group (EPSG)
These numeric codes are used by many desktop and online mapping systems to document and represent the coordinate systems of available data and services
Links to an online version of the registry and downloadable databases of the registry are available from: http://www.epsg.org/Geodetic.html.
Projection Parameters
The parameters that define a map projection may be looked up in a number of online locations:
Decent search tool, includes non-EPSG as well as EPSG projection information, multiple descriptions of projection parameters - http://spatialreference.org/
Services Oriented Architectures
Where have we come from - ENIAC (1946)
ENIAC Computer
First general purpose electronic computer
Programmable, but could not store programs
Where have we come from - Early Client-Server Computing (1960s)
IBM 704 Mainframe ComputerModel 33 ASR TeletypeTeleVideo 925 ASCII Terminal
Mainframe computers to which client terminals connected over a local network
Computing performed by server, client purely a display device
Where have we come from - Personal Computers (1970s)
IBM 5150 Personal ComputerApple I Personal Computer
Desktop computers capable of running a variety of operating systems and applications
In some environments can be interconnected to a central local server
GML is an XML grammar for representing geospatial features and their associated attributes
In its generic form it can encode points, lines, and polygons and their associated attributes
As an XML schema GML was designed to be extensible by communities of practice for consistent encoding of geographic data more richly than allowed by the generic default model
GML documents representing large complex geometries can be quite large - therefore slow to transfer over the Internet
OGC KML
An XML specification that supports the encoding of representation and embedding of geospatial data for use in geospatial viewers
Began as the underlying representation language of Google Earth (originally developed by Keyhole for their virtual Earth viewer)
Adopted as an OGC standard in 2008
Supports data linkage through
Embedding
Reference through external URLs - with WMS specifically supported through parameterization
Includes support for the representation of time in relation to data objects
The OGC web service specifications support key geospatial data access requirements
WMS
visualization of geospatial data through simple web requests
WFS
delivery of geospatial data (typically points, lines, and polygons) in a format that is usable in GIS and other applications
WCS
delivery of geospatial data (typically, but not limited to, raster data) usable in other applications
OGC Summary
The OGC data and representation standards support data exchange and higher level representation
GML
XML schema for the representation of features and associated attributes. It may be extended for use by specific communities of users (i.e. ecological data models)
KML
XML schema that supports the combination of embedded data and external data into a complete representation model that may be used by client applications to present the data through a user interface (e.g. Google Earth, WorldWind)
Week 6 - Module 4a - Interoperability Standards. WMS, KML and XML
Overview
Extensible Markup Language - XML
Definition of a markup language
Requirements
Extensible ???
KML - AKA Keyhole Markup Language
An XML Document Format
Combined representation of spatial data and time
OGC Web Map Services (WMS)
Requests and Results
GetCapabilities, GetMap, GetFeatureInfo
Integration of WMS into KML
Extensible Markup Language - XML
XML Background
SGML Relationship with XML and HTML
Defined as a markup language profile of Standard Generalized Markup Language (SGML - ISO 8879:1986)
<?xml version="1.0" encoding="ISO-8859-1"?><!-- Some comment would go here to describe this document ... --><note><to>Tove</to><from>Jani</from><heading>Reminder</heading><body type="instruction">Don't forget me this weekend!</body></note>
<?xml version="1.0" encoding="ISO-8859-1"?><!-- Some comment would go here to describe this document ... -->
XML Elements
Define blocks of content
3
4
5
6
7
8
<note><to>Tove</to><from>Jani</from><heading>Reminder</heading><body type="instruction">Don't forget me this weekend!</body></note>
XML Root Element
Required
There is only one
It must be a pair of opening and closing tags
3
4
5
6
7
8
<note>
...
...
...
...
</note>
XML Content Elements
Contain all other document content
May be paired opening and closing tags, or
May be self-closing with a terminal "/" in the element, e.g. <br />
4
5
6
7
<to>Tove</to><from>Jani</from><heading>Reminder</heading><body type="instruction">Don't forget me this weekend!</body>
XML Attributes
Define additional information about elements as name=value pairs.
7
<body type="instruction">Don't forget me this weekend!</body>
XML Element Content
The material contained between the opening and closing tags of an Element.
7
<body type="instruction">Don't forget me this weekend!</body>
Valid XML?
Why is this XML well-formed but not valid?
There is no DTD or Schema defined for the document against which it can be validated
1
2
3
4
5
6
7
8
<?xml version="1.0" encoding="ISO-8859-1"?><!-- Edited by XMLSpy® --><note><to>Tove</to><from>Jani</from><heading>Reminder</heading><body type="instruction">Don't forget me this weekend!</body></note>
Common XML Constructs
Document Type Declaration (DTD) references (PROLOG)
definition, either by reference or by direct inclusion, the allowed structure of an XML document, for example:
<!DOCTYPE greeting SYSTEM "hello.dtd">
CDATA Sections
blocks of XML that contain characters that would otherwise be recognized as XML markup, for example:
<![CDATA[<greeting>Hello, world!</greeting>]]>
XML Namespace Declarations
additional information included in elements to distinguish between duplicate element names, for example (declared in lines 1-3, used in lines 5-17):
This International Standard specifies the behaviour of a service that provides transactions on and access to geographic features in a manner independent of the underlying data store. It specifies discovery operations, query operations, locking operations, transaction operations and operations to manage stored parameterized query expressions.
Discovery operations allow the service to be interrogated to determine its capabilities and to retrieve the application schema that defines the feature types that the service offers.
Query operations allow features or values of feature properties to be retrieved from the underlying data store based upon constraints, defined by the client, on feature properties.
Locking operations allow exclusive access to features for the purpose of modifying or deleting features.
Transaction operations allow features to be created, changed, replaced and deleted from the underlying data store.
Stored query operations allow clients to create, drop, list and described parameterized query expressions that are stored by the server and can be repeatedly invoked using different parameter values.
WFS Requests/Operations
These request types are submitted as part of the required REQUEST key in a KVP HTTP GET request.
GetCapabilities
service metadata (XML) that documents the types of features supported by the service and the operations supported by each feature type
DescribeFeatureType
metadata (XML) that describes the structure of supported feature types
GetPropertyValue
a request for the value(s) of a specified property for a specified featuretype
GetFeature (GetFeatureWithLock)
a request for actual features (XML, or other formats) from the service. The request may include both spatial and non-spatial query constraints
LockFeature
Feature locking operation
Transaction
a request to a WFS that may create, update, or delete features
CreateStoredQuery
a request to create a named WFS query that is stored on the server for future reuse
DropStoredQuery
a request to remove a named WFS query that has previously been stored on the server
ListStoredQueries
a request to retrieve a list of named WFS queries that have been stored on the server
DescribeStoredQueries
a request for more detailed information about specific named WFS queries that are stored on the server
WFS Conformance Levels
WFS 2.0.0 Requests and their corresponding WFS Compliance Levels
Operation (REQUEST=)
V 1.1.0
V 2.0.0
Simple
Basic
Transactional
Locking
GetCapabilities
DescribeFeatureType
ListStoredQueries
DescribeStoredQueries
GetFeature
StoredQuery
GetPropertyValue
Transaction
GetFeatureWithLock
LockFeature
GetGMLObject
Request Composition
Requests submitted to a WFS may be submitted either via
HTTP GET
a request that includes all request parameters within the URL submitted to the service. Request parameters are included in the URL as “key=value” pairs (KVPs)
HTTP POST
a request where the URL consists of only the Host and path, with all other request parameters included in the body of the POST document submitted to the service. The request parameters supplied to the server are encoded as XML within the POST document.
SOAP
a request submitted as an encapsulated message within a SOAP transaction.
Servers implementing WFS may support either the HTTP GET, POST, or SOAP request model
Conceptually FeatureType = Layer
KVP for Base WFS Requests
Base request parameters for all HTTP GET KVP requests (Figure 1)
The OGC Web Coverage Service (WCS) supports electronic retrieval of geospatial data as "coverages" – that is, digital geospatial information representing space/time-varying phenomena.
This document specifies the WCS core; every implementation of a WCS shall adhere to this standard. This standard thus defines only basic requirements. Extensions to the core will define extensions to meet additional requirements, such as the response encoding. Indeed, additional extensions are required in order to completely specify a WCS for implementation.
A WCS provides access to coverage data in forms that are useful for client-side rendering, as input into scientific models, and for other clients. The WCS may be compared to the OGC Web Feature Service (WFS) and the Web Map Service (WMS). As WMS and WFS service instances, a WCS allows clients to choose portions of a server's information holdings based on spatial constraints and other query criteria.
WCS Requests/Operations
GetCapabilities
service metadata (XML) that documents the service, including brief information about the data coverages available from the service
DescribeCoverage
a request for more detailed metadata (XML) for one or more coverages listed in the output of the GetCapabilities request
GetCoverage
a request for an actual data product representing a specified coverage. The specific data formats available for delivery will vary from service to service.
Request Composition
Requests submitted to a WCS may be submitted either via the following protocols, as defined in the three extensions developed thus far for the core WCS standard.
HTTP GET
a request that includes all request parameters within the URL submitted to the service. Request parameters are included in the URL as “name=value” pairs. Extension Link
HTTP POST
a request where the URL consists of only the Host and path, with all other request parameters included in the body of the POST document submitted to the service. The request parameters supplied to the server are encoded as XML within the POST document. Extension Link
XML/SOAP
a request-response model between the client that conforms with the W3C SOAP web services protocol Extension Link
Support for Multiple basemaps: BingMaps, MapQuest, OpenStreetMap, Stamen
Model for interaction with multiple map server platforms: ArcGIS (REST), MapServer, GeoServer
Support for key OGC standards: WMS, WMTS, WFS, GML, KML
Multiple control types: Attribution, Zoom, Overview, Scale, FullScreen, Graticule
Custom styled features with associated attributes: Curve, LinearRing, LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon
Support for many formats for data read and write: ATOM, GML (1, 2, 3), GeoJSON, GPX, KML, WKT, any many others
Open Source, enabling modification and integration into other systems (e.g. GeoExt)
Distinguishing Characteristics Between OpenLayers and Google Maps
Greater emphasis on client-side processing - Client access and rendering of data files that Google's servers otherwise take care of (pros & cons to this approach)
Integrated support for OGC services and their products
Support for different projections (adds complexity)
<html><head><link rel="stylesheet" href="css/OpenLayers_01.css" type="text/css"><link rel="stylesheet" href="http://openlayers.org/en/v3.14.2/css/ol.css" type="text/css"><!-- you can use this line if you want to use the hosted version instead of the local copy --><!-- <script src="http://openlayers.org/en/v3.14.2/build/ol.js" type="text/javascript"></script> --><script src="js/v3.14.2/build/ol.js" type="text/javascript"></script></head><body><h1>This is a very simple OpenLayers 3 sample map page</h1><div id='map'><!-- This is where the map will be displayed --></div><!-- import the external Javascript file with the map configuration code --><script src="js/OpenLayers_01.js" type="text/javascript"></script></body></html>
OpenLayers_01.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// OpenLayers_01.js
var myMap = new ol.Map({
target: 'map',
layers: [
new ol.layer.Tile({
source: new ol.source.MapQuest({layer: 'sat'})
})
],
view: new ol.View({
center: ol.proj.fromLonLat([-106.624083,35.08427]),
zoom: 18
})
});
// create a map with minimum required elements and default
// options in an element with the id "map1"
var map = new ol.Map({
target:'map1',
// a map without layers can be defined and in that case a map with no layers
// will be rendered
layers: [
new ol.layer.Tile({
source: new ol.source.MapQuest({layer: 'osm'})
})
], // end layers
view: new ol.View({
center: [0, 0],
zoom: 1
}), //end view
});
// create a map with options specified in a separate 'options' variable and
// included by reference in the code to create the new map object
var options = {
// required options
target:'map2',
layers: ...,
view: ...,
// optional options - only include those that you need
controls: ...,
pixelRatio: ...,
interactions: ...,
keyboardEventTarget: ...,
loadTilesWhileAnimating: ...,
loadTilesWhileInteracting: ...,
logo: ...,
overlays: ...,
renderer: ...
};
var map = new ol.Map(options);
// map with non-default options - same as above but with a single argument
var map = new ol.Map({
// required options
target:'map2',
layers: ...,
view: ...,
// optional options - only include those that you need
controls: ...,
pixelRatio: ...,
interactions: ...,
keyboardEventTarget: ...,
loadTilesWhileAnimating: ...,
loadTilesWhileInteracting: ...,
logo: ...,
overlays: ...,
renderer: ...
});
// the following commands can be executed to add, set or remove the layers in a map
// after a map object has been created
map.addLayer(layer)
map.removeLayer(layer)
map.setLayerGroup(layerGroup)
// the view of a layer can be created or modified after the map object has been
// created by using the following command
map.setView()
// the target DOM object for the map object can be set or changed using
// the following command
map.setTarget
Layer Object Options
Layer Types and a subset of sources for each type
ol.layer.Image - a single map image is rendered for this layer type
ol.source.ImageMapGuide - API source is a MapGuide server hosting data of interest.
ol.source.ImageStatic - API source renders a specified static image file within a specified extent within the map.
ol.source.ImageWMS - API source retrieves a single map image from the specified OGC Web Map Service (WMS).
ol.layer.Tile - map images in a tiled grid are rendered for this layer type
ol.source.TileArcGISRest - API source is an ArcGIS REST map or image service
ol.source.TileWMS - API source is an OGC Web Map Service (WMS)
ol.source.WMTS - API source is an OGC Web Map Tile Service (WMTS)
ol.layer.VectorTile - map content is delivered vector data that has been divided into a tile grid and cannot be edited
ol.source.VectorTile - API source delivers vector data tiles for rendering in the client (example
ol.layer.Vector - map content is delivered as vector data that is rendered by the client and may be edited within the client
ol.source.Vector - API the source for vector feature(s) that constitute a vector layer. The individual features are ol.Feature objects that consist of at least one geometry, or a collection of geometries and any additional attributes that are associated with each feature.
Common Pattern of Layer Object Creation (varies some depending upon the specific layer type)
1
2
3
4
5
6
var layer = new ol.layer.***({
source: new ol.source.***({
...
}),
other options ...
})
Additional Map and Layer Object Functions & Events
Both Map and Layer Objects have a number of associated functions as well
Retrieving object properties programmatically with Get functions.
Modifying existing object properties with Set functions
Map destruction, and reconfiguration
Linkage of object events with Javascript functions
WMS Layer Configuration
Some key issues to be aware of when using the two WMS supporting layers (ol.layer.Tile, and ol.layer.Image) and their associated WMS sources (ol.source.TileWMS and ol.source.ImageWMS respectively) include:
The projection of the map object must be supported by the included WMS service (review the WMS GetCapabilities response to see what projections are supported by the service). If you don't specify a projection parameter as part of the map object's view property a default Web Mercator (EPSG:3857) projection is used for the map. Information about how to define and set map projections in OpenLayers is found here
The layers parameter as part of the params option must be provided as part of the server-related property list (the layer names may also be found in the GetCapabilities response)
Other WMS parameters (again as part of the params option) may be provided as well to "adjust" the request automatically generated by OpenLayers
Use of a tiled WMS may produce unwanted repetition of labels included in the WMS. If that is the case you can use a single-image ol.layer.Image layer type to allow the WMS server to handle the distribution of layers across the entire map image instead of including them in each individual map image.
var basemap_single = new ol.layer.Image({
source: new ol.source.ImageWMS({
attributions: new ol.Attribution({
html: 'Blue Marble Next Generation:' +
'R. Stockli, E. Vermote, N. Saleous, R. Simmon and D. Herring (2005). The Blue Marble Next Generation - A true color earth dataset including seasonal dynamics from MODIS. Published by the NASA Earth Observatory. Corresponding author: rstockli@climate.gsfc.nasa.gov'
}),
params: {'LAYERS':'global:BMNG_west'},
url: 'http://mapper.karlbenedict.com:8080/geoserver/global/wms?',
serverType: 'geoserver'
})
})
var states_single = new ol.layer.Image({
source: new ol.source.ImageWMS({
attributions: new ol.Attribution({
html: 'State Boundary Restructured - USGS, National Atlas Release 5-14-12'
}),
params: {'LAYERS':'global:statep010'},
url: 'http://mapper.karlbenedict.com:8080/geoserver/global/wms?',
serverType: 'geoserver'
})
})
var singleMap = new ol.Map({
target: 'map_image',
layers: [basemap_single,states_single],
view: new ol.View({
center: ol.proj.fromLonLat([-98.58,39.83]), // the approximate geographic center of the continental US
zoom: 3,
projection: 'EPSG:3857'
})
});
var classroomCoord = [-106.624073,35.084280]
var officeCoord = [-106.624899,35.084506]
var classroomPoint = new ol.geom.Point(classroomCoord);
var officePoint = new ol.geom.Point(officeCoord);
var blocks_kml = new ol.layer.Vector({
source: new ol.source.Vector({
url: 'https://s3.amazonaws.com/kkb-web/data/tl_2010_35001_tabblock10.kml',
projection: projection,
format: new ol.format.KML()
})
})
var county_style = new ol.style.Style({
fill: new ol.style.Fill({
color: county_color
}),
stroke: new ol.style.Stroke({
color: county_color,
width: 1
}),
});
var counties_kml_styled = new ol.layer.Vector({
source: new ol.source.Vector({
url: 'https://s3.amazonaws.com/kkb-web/data/2007fe_35_county00.kml',
projection: projection,
format: new ol.format.KML({'extractStyles':false}),
style: county_style
})
})
If in doubt, check the information in the metadata
Select the layer type you would like to from "Layer" menu, or click the button in the interface to add a specific layer type.
QGIS - Adding Services and Layers - adding a service
Add a service to the list of services in the menu (if necessary - QGIS retains information about previously added services) by selecting the "New" option under the service list in the "Add Layer(s) from a Server" dialog
"Add Layer(s) from a Server" dialog
QGIS - Adding Services and Layers - adding connection information
Add the name, base URL and any additional information about the service to the connection dialog box
Connection dialog box
QGIS - Adding Services and Layers - connecting to and adding layers from the service
After adding the service, you can select it from the service list in the "Add Layer(s) from a Server" dialog box, connect to the service to retrieve the GetCapabilities response from the service, select the layers and other options advertised by the service through its response, and add them to your map.
"Add Layer(s) from a Server" dialog with service connection and layer selection process
QGIS - Adding Services and Layers - the final added layer
After adding the layer, it appears as an available layer in the table of contents for your map.
Based upon the results of a GetCapabilities request against a remote service. GetCapabilities request information provided as either:
The base URL to which the OGC service parameters would be added
A complete GetCapabilities request against the service
This model applies to ArcGIS just as it did for Quantum GIS - the base URL is provided to the various ArcGIS components that support the addition of OGC services to the client interface.
The addition of OGC WMS and WCS layers to ArcMap is through the same process of
Select the "add data" button
WMS/WCS services are added through the "GIS Servers" option in the "Add Data" dialog
If you have not previously added the service from which you want to add layers, you select "Add WMS Server" or "Add WCS Server" from the list of options in the "Add Data" dialog
You then provide the BASE GetCapabilities URL to the "ADD WMS/WCS Server" dialog that appears
Click "OK", and the new WMS/WCS service is added to the list of services that is available when you choose to add a WMS service.
You then select the layer(s) from the service that you want to add to your map and click the "add" button in the dialog.
WFS support in ArcGIS 10.0 and beyond requires that the "Data Interoperability Extension" be installed (though it doesn’t have to be enabled)
Connections to WFS services are defined through ArcCatalog's "Interoperabilty Connections" "Add Interoperability Connection" option
After defining the connection in ArcCatalog (including the specification of the interoperabilty connection type, desired feature types, and maximum number of features to return), its feature types are available through that Interoperability Connection that may be added to ArcMap and other ArcGIS components
Once the connection is created, WFS data may be added through the "Add Data" dialog in ArcMap
ArcGIS WFS Configuration Resources
Steps for connecting to an OGC WFS from within ArcCatalog 10.2
A GetCapabilities request is the key for configuring most OGC client applications to access remote services
The specific way in which the GetCapabilities request is given to the client varies from client to client
Clients can auto/mis-configure themselves based upon the GetCapabilities XML response - when troubleshooting problems with an advertised service, try the manual request approach for the GetCapabilities, data and maps that you have learned about to determine if the service is functioning as advertised.
Module 5 - Platforms and GeoServer Introduction
Overview
SOA Review
Server Platform
Online Mapping Server Applications: COTS & Open Source
What is GeoServer
Working with GeoServer
Demonstration
SOA Review
SOA Illustration
Services Oriented Architecture (SOA) for Geospatial Data and Processing
Data, Processing & Client Tiers
Open Geospatial Consortium Interoperability Standards
WMS, WFS, WCS
Geospatial Metadata Standards
ISO 19115, FGDC
Internet Standards
Web: HTML, CSS, JavaScript, XML
SOAP - Simple Object Access Protocol
REST - Representation State Transformation
Server Platform
In the context of server platforms for online mapping with OGC services, there are several components that are of interest
The operating system - the software environment in which all applications on a computer operate (e.g. Windows, Mac OS X, Linux)
The web server - the application that listens for incoming requests from the Internet (e.g. Apache, IIS)
The mapping server - the application (that may also include the web server) that enables online mapping applications, that may include support for one or more OGC service interfaces (e.g. GeoServer, MapServer, CubeWerx, ArcGIS Server)
After the initial setup as part of the installation process, other setup and configuration is performed through the web interface
All configuration activities require that you are logged in as an administrator
Default username and password for a new GeoServer are admin:geoserver
After logging in you can view and modify the configuration of the server and services - some of the configuration elements inform the OGC service capabilities
Server Configuration Options
Geoserver Configuration Menu
Server Status - summary information about the status of the currently running server
GeoServer Logs - access to the application logs for diagnosing issues with the server
Contact Information - contact information for the person responsible for providing support for the server and services. This information is used to build parts of the Capabilities XML metadata returned by the services
About GeoServer - links to information about GeoServer
Global Settings - settings that apply to the whole server - primarily focussed on options for logging
JAI Settings - settings related to the Java Advanced Imagery engine within GeoServer
Coverage Access - configuration information for the tuning of processing resources for the server
WxS Service Configuration Options
Geoserver Service Configuration Menu
Options Common to all WxS services
Enable/disable the service, with or without strict CITE compliance
Maintainer and Online Resource URLs
Title/Abstract
Fees/Access Constraints
Keywords
Options specific to individual services
WFS - max. no. features, service type (basic/transactional/complete), GML-specific styles, other options
WMS - SRS subset specification, interpolation method, resource consumption limits, KML options, map image watermarking, PNG/JPEG/SVG format options, and others
WCS - SRS subset specification, policies for overviews to be used, subsampling, and resource consumption limits, other options
Data Component Configuration Options
GeoServer Data Configuration Menu
Layer Preview - An interface through which a Layers may be previewed in a variety of formats
Workspaces - Defined containers for related data products
Stores - Specific data sources (file or service based) with required data type and connection information provided in the Store configuration
Layers - Defined layers that are published by the server, with the layers based upon data provided by a Store, but with additional layer-specific settings (such as bounding box, applied and available styles,and attribution).
Layer Groups - Collections of Layers for specific projects/applications or other logical groupings.
Styles - A listing of defined layer styles for the server through which those styles may be accessed and managed.
Data Integration Process
Data integration workflow
Security Settings
GeoServer Security Configuration Menu
Settings - Basic security configuration settings: role service, encryption options
Authentication - Configuration settings for authentication providers for users
Passwords - Settings related to underlying password providers and policies
Users, Groups, Roles - Management of system users, groups and defined roles
Data - Settings for read/write access to data products within the server, settings for the system's catalog mode
Service - Settings for managing service-level (i.e. WMS, WFS, WCS and related request types) access privileges by user role.
A KMZ file may be extracted and its contents examined by many zipfile utilities if you replace the .kmz extension with .zip prior to trying to extract↩